package com.algoshow.view;

import com.algoshow.DTO.DataDTO;
import com.algoshow.controller.AlgoController;
import com.algoshow.utils.SystemConstants;
import com.algoshow.utils.SystemUtils;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import static com.algoshow.utils.SystemConstants.SYSTEM_HEIGHT;
import static com.algoshow.utils.SystemConstants.SYSTEM_WIDTH;


/**
 * @author vvv
 * @date 2023-05-14 22 57
 * discription
 */

public class SecondMenu{
    private JPanel jb;

    private JFrame frame;

    private JPanel backgroundPanel;
    private JButton btn1,btn2,btn3,btn4,btn5,btn6;
    private JButton ctn1,ctn2,ctn3,ctn4,ctn5,ctn6,stn1,stn2,stn3;
    private JButton dtn1,dtn2,dtn3,dtn4,dtn5,dtn6,etn1,etn2,etn3,etn4;
    private Color defaultColor = Color.BLACK;
    private Color hoverColor = Color.WHITE;
    private JLabel label;

    private AlgoController algoController = new AlgoController();

    public static void main(String[] args) {
        new SecondMenu().showTest2();
        new SecondMenu().showTest3();
        new SecondMenu().showTest4();
        new SecondMenu().showTest5();
        new SecondMenu().showTest6();
        new SecondMenu().showTest7();

    }


    public SecondMenu() {
        // 创建主窗口
        frame = new JFrame("Window with Background");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(SYSTEM_WIDTH, SYSTEM_HEIGHT);
        frame.setLocationRelativeTo(null); // 设置窗口位置为屏幕中心

        // 创建背景容器
        backgroundPanel = new JPanel() {
            // 重写paintComponent方法以绘制背景图片
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                // 在这里设置图片
                Image backgroundImage = new ImageIcon("src/resources/background.jpg").getImage();
                g.drawImage(backgroundImage, 0, 0, getWidth(), getHeight(), this);
            }
        };
        backgroundPanel.setLayout(null);  // 使用绝对布局以便手动设置按钮位置

        // 创建按钮
        JButton btn1 = new JButton("返回菜单");


        btn1.setBounds(50,50,350,100);
        btn1.setContentAreaFilled(false);      //按钮透明
        btn1.setBorderPainted(false);  //无边框
        btn1.setFont(new Font("宋体", Font.ROMAN_BASELINE, 40));
        btn1.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        btn1.setForeground(defaultColor);
        //给按钮绑定点击事件
        btn1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                frame.dispose();
                new FirstMenu();
            }
        });
        // 设置鼠标动作事件监听器
        btn1.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                btn1.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                btn1.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(btn1);
        /*************/
        //创建按钮

        // 将背景容器添加到主窗口
        frame.getContentPane().add(backgroundPanel);

        frame.setVisible(true);
    }


    //TODO 图
    public void showTest7(){
        //图的深度优先遍历
        JButton etn3=new JButton("图的深度优先遍历");
        etn3.setBounds(750,270,450,100);
        etn3.setContentAreaFilled(false);      //按钮透明
        etn3.setBorderPainted(false);  //无边框
        etn3.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        etn3.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        etn3.setForeground(defaultColor);
        //给按钮绑定点击事件
        etn3.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入有向图");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.STACK_BRACKET_MATCHING, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        etn3.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                etn3.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                etn3.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(etn3);

        //图的广度优先遍历
        JButton etn4=new JButton("图的广度优先遍历");
        etn4.setBounds(750,500,450,100);
        etn4.setContentAreaFilled(false);      //按钮透明
        etn4.setBorderPainted(false);  //无边框
        etn4.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        etn4.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        etn4.setForeground(defaultColor);
        //给按钮绑定点击事件
        etn4.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入有向图");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.STACK_BRACKET_MATCHING, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        etn4.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                etn4.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                etn4.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(etn4);



    }
    //TODO 栈
    public void showTest6(){
        //括号匹配
        JButton etn1=new JButton("括号匹配");
        etn1.setBounds(750,270,350,100);
        etn1.setContentAreaFilled(false);      //按钮透明
        etn1.setBorderPainted(false);  //无边框
        etn1.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        etn1.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        etn1.setForeground(defaultColor);
        //给按钮绑定点击事件
        etn1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入需要匹配的括号");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidBracket(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.STACK_BRACKET_MATCHING, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        etn1.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                etn1.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                etn1.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(etn1);

        //表达式求值
        JButton etn2=new JButton("表达式求值");
        etn2.setBounds(750,500,350,100);
        etn2.setContentAreaFilled(false);      //按钮透明
        etn2.setBorderPainted(false);  //无边框
        etn2.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        etn2.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        etn2.setForeground(defaultColor);
        //给按钮绑定点击事件
        etn2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入表达式");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.STACK_BRACKET_MATCHING, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        etn2.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                etn2.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                etn2.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(etn2);

    }

    //  TODO 链表
    public void showTest5(){
        //链表i位插入
        JButton dtn1=new JButton("链表i位插入");
        dtn1.setBounds(750,270,350,100);
        dtn1.setContentAreaFilled(false);      //按钮透明
        dtn1.setBorderPainted(false);  //无边框
        dtn1.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        dtn1.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        dtn1.setForeground(defaultColor);
        //给按钮绑定点击事件
        dtn1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 按着这里例子，如果用户要输入index 和 value 的话就这样写
                String data = JOptionPane.showInputDialog(null, "请输入链表数据");
                if (data == null) {
                    return;
                }
                String index = JOptionPane.showInputDialog(null, "请输入插入位置");
                if (index == null) {
                    return;
                }
                if (Integer.valueOf(index) > data.length()) {
                    JOptionPane.showMessageDialog(null
                            , "插入位置大于链表大小"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                String value = JOptionPane.showInputDialog(null, "请输入插入节点");
                if (value == null) {
                    return;
                }
                // 验证用户输入的全部数据是否合法
                boolean flag = SystemUtils.isValidData(data) && SystemUtils.isValidInsert(index)
                        && SystemUtils.isValidValue(value) ;
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                // 最后按这个格式把用户输入的数据搞到这个dataDto里面
                DataDTO dataDTO = new DataDTO(data, Integer.valueOf(index), Integer.valueOf(value));
                algoController.start(SystemConstants.LIST_INSERT, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        dtn1.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                dtn1.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                dtn1.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(dtn1);

        //链表i位删除
        JButton dtn2=new JButton("链表i位删除");
        dtn2.setBounds(750,500,350,100);
        dtn2.setContentAreaFilled(false);      //按钮透明
        dtn2.setBorderPainted(false);  //无边框
        dtn2.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        dtn2.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        dtn2.setForeground(defaultColor);
        //给按钮绑定点击事件
        dtn2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 按着这里例子，如果用户要输入index 和 value 的话就这样写
                String data = JOptionPane.showInputDialog(null, "请输入链表数据");
                if (data == null) {
                    return;
                }
                String index = JOptionPane.showInputDialog(null, "请输入需删除的节点");
                if (index == null) {
                    return;
                }
                if (Integer.valueOf(index) > data.length()) {
                    JOptionPane.showMessageDialog(null
                            , "删除位置大于链表大小"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                // 验证用户输入的全部数据是否合法
                boolean flag = SystemUtils.isValidData(data) && SystemUtils.isValidInsert(index);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                // 最后按这个格式把用户输入的数据搞到这个dataDto里面
                DataDTO dataDTO = new DataDTO(data, Integer.valueOf(index),-1);
                algoController.start(SystemConstants.LIST_DELETE, dataDTO);
            }
        });

                // 设置鼠标动作事件监听器
        dtn2.addMouseListener(new MouseAdapter() {
             @Override
             public void mouseEntered(MouseEvent e) {dtn2.setForeground(hoverColor);}

             @Override
             public void mouseExited(MouseEvent e) {dtn2.setForeground(defaultColor);}
        });
        backgroundPanel.add(dtn2);


    }
    // TODO 顺序表
    public void showTest4() {
        //顺序表i位删除
        JButton ctn4=new JButton("顺序表i位删除");
        ctn4.setBounds(750,270,400,100);
        ctn4.setContentAreaFilled(false);      //按钮透明
        ctn4.setBorderPainted(false);  //无边框
        ctn4.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        ctn4.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        ctn4.setForeground(defaultColor);
        //给按钮绑定点击事件
        ctn4.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 按着这里例子，如果用户要输入index 和 value 的话就这样写
                String data = JOptionPane.showInputDialog(null, "请输入顺序表数据");
                if (data == null) {
                    return;
                }
                String index = JOptionPane.showInputDialog(null, "请输入需删除节点");
                if (index == null) {
                    return;
                }
                if (Integer.valueOf(index) > data.length()) {
                    JOptionPane.showMessageDialog(null
                            , "删除位置大于顺序表大小"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                // 验证用户输入的全部数据是否合法
                boolean flag = SystemUtils.isValidData(data) && SystemUtils.isValidInsert(index);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                // 最后按这个格式把用户输入的数据搞到这个dataDto里面
                DataDTO dataDTO = new DataDTO(data, Integer.valueOf(index), -1);
                algoController.start(SystemConstants.ARRAY_DELETE, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        ctn4.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                ctn4.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                ctn4.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(ctn4);

        //顺序表i位插入
        JButton ctn5=new JButton("顺序表i位插入");
        ctn5.setBounds(750,500,400,100);
        ctn5.setContentAreaFilled(false);      //按钮透明
        ctn5.setBorderPainted(false);  //无边框
        ctn5.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        ctn5.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        ctn5.setForeground(defaultColor);
        //给按钮绑定点击事件
        ctn5.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 按着这里例子，如果用户要输入index 和 value 的话就这样写
                String data = JOptionPane.showInputDialog(null, "请输入顺序表数据");
                if (data == null) {
                    return;
                }
                String index = JOptionPane.showInputDialog(null, "请输入节点位置");
                if (index == null) {
                    return;
                }
                if (Integer.valueOf(index) > data.length()) {
                    JOptionPane.showMessageDialog(null
                            , "插入位置大于顺序表大小"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                String value = JOptionPane.showInputDialog(null, "请输入插入的节点");
                if (value == null) {
                    return;
                }
                // 验证用户输入的全部数据是否合法
                boolean flag = SystemUtils.isValidData(data) && SystemUtils.isValidInsert(index)
                        && SystemUtils.isValidValue(value);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                // 最后按这个格式把用户输入的数据搞到这个dataDto里面
                DataDTO dataDTO = new DataDTO(data, Integer.valueOf(index), Integer.valueOf(value));
                algoController.start(SystemConstants.ARRAY_INSERT, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        ctn5.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                ctn5.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                ctn5.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(ctn5);

    }

    // TODO 二叉树
    public void showTest3() {
        //二叉树前序递归
        JButton ctn1=new JButton("前序递归");
        ctn1.setBounds(350,250,350,100);
        ctn1.setContentAreaFilled(false);      //按钮透明
        ctn1.setBorderPainted(false);  //无边框
        ctn1.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        ctn1.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        ctn1.setForeground(defaultColor);
        //给按钮绑定点击事件
        ctn1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入建树数据(输入层序遍历，空值为x)");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.TREE_PREORDER, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        ctn1.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                ctn1.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                ctn1.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(ctn1);


        //二叉树中序递归
        JButton ctn2=new JButton("中序递归");
        ctn2.setBounds(350,400,350,100);
        ctn2.setContentAreaFilled(false);      //按钮透明
        ctn2.setBorderPainted(false);  //无边框
        ctn2.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        ctn2.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        ctn2.setForeground(defaultColor);
        //给按钮绑定点击事件
        ctn2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入建树数据(输入层序遍历，空值为x)");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.TREE_INORDER, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        ctn2.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                ctn2.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                ctn2.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(ctn2);


        //二叉树后序递归
        JButton ctn3=new JButton("后序递归");
        ctn3.setBounds(350,550,350,100);
        ctn3.setContentAreaFilled(false);      //按钮透明
        ctn3.setBorderPainted(false);  //无边框
        ctn3.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        ctn3.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        ctn3.setForeground(defaultColor);
        //给按钮绑定点击事件
        ctn3.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入建树数据(输入层序遍历，空值为x)");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.TREE_POSTORDER, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        ctn3.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                ctn3.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                ctn3.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(ctn3);
        //二叉树层序遍历
        JButton ctn6=new JButton("层序遍历");
        ctn6.setBounds(350,700,350,100);
        ctn6.setContentAreaFilled(false);      //按钮透明
        ctn6.setBorderPainted(false);  //无边框
        ctn6.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        ctn6.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        ctn6.setForeground(defaultColor);
        //给按钮绑定点击事件
        ctn6.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入建树数据(输入层序遍历，空值为x)");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.TREE_LEVELORDER, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        ctn6.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                ctn6.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                ctn6.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(ctn6);


        //tree前序非递归
        JButton stn1=new JButton("前序非递归");
        stn1.setBounds(1050,250,350,100);
        stn1.setContentAreaFilled(false);      //按钮透明
        stn1.setBorderPainted(false);  //无边框
        stn1.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        stn1.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        stn1.setForeground(defaultColor);
        //给按钮绑定点击事件
        stn1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入建树数据(输入层序遍历，空值为x)");
                // 1. data == null 就是用户没有输入直接return
               // System.out.println(Integer.valueOf(data));
                if (data == null||data=="") {
                    return ;
                }

                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.TREE_STACK_PREORDER, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        stn1.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                stn1.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                stn1.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(stn1);


        //中序非递归
        JButton stn2=new JButton("中序非递归");
        stn2.setBounds(1050,400,350,100);
        stn2.setContentAreaFilled(false);      //按钮透明
        stn2.setBorderPainted(false);  //无边框
        stn2.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        stn2.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        stn2.setForeground(defaultColor);
        //给按钮绑定点击事件
        stn2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入建树数据(输入层序遍历，空值为x)");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.TREE_STACK_INORDER, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        stn2.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                stn2.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                stn2.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(stn2);


        //后序非遍历
        JButton stn3=new JButton("后序非遍历");
        stn3.setBounds(1050,550,350,100);
        stn3.setContentAreaFilled(false);      //按钮透明
        stn3.setBorderPainted(false);  //无边框
        stn3.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        stn3.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        stn3.setForeground(defaultColor);
        //给按钮绑定点击事件
        stn3.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入建树数据(输入层序遍历，空值为x)");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.TREE_STACK_POSTORDER, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        stn3.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                stn3.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                stn3.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(stn3);

    }
    public void showTest2() {
        JButton btn2 = new JButton("冒泡排序");
        btn2.setBounds(750, 250, 350, 100);
        btn2.setContentAreaFilled(false);      //按钮透明
        btn2.setBorderPainted(false);  //无边框
        btn2.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        btn2.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        btn2.setForeground(defaultColor);
        //给按钮绑定点击事件
        btn2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入需排序数据大小");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.SORT_BUBBLE, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        btn2.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                btn2.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                btn2.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(btn2);

        //直接插入排序
        JButton btn3= new JButton("直接插入排序");
        btn3.setBounds(750, 400, 350, 100);
        btn3.setContentAreaFilled(false);      //按钮透明
        btn3.setBorderPainted(false);  //无边框
        btn3.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        btn3.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        btn3.setForeground(defaultColor);
        btn3.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入需排序数据大小");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.SORT_INSERT, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        btn3.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                btn3.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                btn3.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(btn3);

        // 简单选择
        JButton btn4 = new JButton("简单选择排序");
        btn4.setBounds(750, 550, 350, 100);
        btn4.setContentAreaFilled(false);      //按钮透明
        btn4.setBorderPainted(false);  //无边框
        btn4.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        btn4.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        btn4.setForeground(defaultColor);
        //给按钮绑定点击事件
        btn4.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入需排序数据大小");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.SORT_SELECT, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        btn4.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                btn4.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                btn4.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(btn4);


        //快速排序
        JButton btn5 = new JButton("快速排序");
        btn5.setBounds(750, 700, 350, 100);
        btn5.setContentAreaFilled(false);      //按钮透明
        btn5.setBorderPainted(false);  //无边框
        btn5.setFont(new Font("宋体", Font.ROMAN_BASELINE, 50));
        btn5.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        btn5.setForeground(defaultColor);
        //给按钮绑定点击事件
        btn5.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String data = JOptionPane.showInputDialog(null, "请输入需排序数据大小");
                // 1. data == null 就是用户没有输入直接return
                if (data == null) {
                    return ;
                }
                // 2. 用这个SystemUtils.方法名 验证用户输入的的数据是否合法
                boolean flag = SystemUtils.isValidData(data);
                if (!flag) {
                    JOptionPane.showMessageDialog(null
                            , "输入格式错误"
                            , "警告", JOptionPane.ERROR_MESSAGE);
                    return;
                }
                frame.dispose();
                //第一个参数的要展示什么算法，第二个参数是用户输入的数据
                DataDTO dataDTO = new DataDTO(data);
                algoController.start(SystemConstants.SORT_FAST, dataDTO);
            }
        });
        // 设置鼠标动作事件监听器
        btn5.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                btn5.setForeground(hoverColor);
            }

            @Override
            public void mouseExited(MouseEvent e) {
                btn5.setForeground(defaultColor);
            }
        });
        backgroundPanel.add(btn5);
    }

    private boolean validSortData(String data) {
        boolean res = true;
        if (data == "" || data == null) {
            return false;
        }
        int maxLength = 20;
        if (data.length() > maxLength) {
            return false;
        }
        for (int i = 0; i < data.length(); i++) {
            char c = data.charAt(i);
            if (!(c >= '0' && c <= '9')) {
                return false;
            }
        }
        return true;
    }

}